/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Logica.Controladoras.Producto;

import Logica.Core.Depositos.Lote;
import Logica.Core.Personal.Insumo;
import Logica.Core.Producto.LeñaSeca;
import Logica.Core.Producto.LeñaVerde;
import Logica.Core.Producto.YerbaCanchada;
import Logica.Core.Producto.YerbaVerde;
import Persistencia.ControladoraPersistencia;
import Persistencia.JPAControllers.exceptions.NonexistentEntityException;
import Persistencia.JPAControllers.exceptions.PreexistingEntityException;
import java.util.LinkedList;
import java.util.List;

/**
 *
 * @author Daniel
 */
public final class ControladoraLogicaProducto {

    protected ControladoraPersistencia miControladora;
    private List<LeñaSeca> misLeñasSecas = new LinkedList<>();
    private List<LeñaVerde> misLeñasVerdes = new LinkedList<>();
    private List<YerbaVerde> misYerbasVerdes = new LinkedList<>();
    private List<YerbaCanchada> misYerbasCanchadas = new LinkedList<>();

    public ControladoraLogicaProducto(ControladoraPersistencia miControladora) {
        this.miControladora = miControladora;

        try {
            misLeñasSecas = dameMisLeñasSecas();
            misLeñasVerdes = dameMisLeñasVerdes();
            misYerbasVerdes = dameMisYerbasVerdes();
            misYerbasCanchadas = dameMisYerbasCanchadas();
        } catch (NullPointerException e) {

            misLeñasSecas = new LinkedList<>();
            misLeñasVerdes = new LinkedList<>();
            misYerbasVerdes = new LinkedList<>();
            misYerbasCanchadas = new LinkedList<>();
        }
    }
        // <editor-fold defaultstate="collapsed" desc="Clase LeñaSeca">
    

    public void crearLeñaSeca(String tipo, double peso, Lote miLote, List<Insumo> misInsumos) throws PreexistingEntityException, Exception {

        misLeñasSecas = dameMisLeñasSecas();
        int nroLeñaSeca = misLeñasSecas.size();
        boolean encontro = false;
        LeñaSeca miNuevaLeñaSeca = new LeñaSeca(tipo, nroLeñaSeca, peso, miLote, misInsumos);


        for (int i = 0; i < misLeñasSecas.size() && !encontro; i++) {
            LeñaSeca miLeñaSeca = misLeñasSecas.get(i);
            if (miLeñaSeca.getId() == nroLeñaSeca) {
                encontro = true;
                throw new PreexistingEntityException("LeñaSeca ya Existente.");
            }
        }

        misLeñasSecas.add(miNuevaLeñaSeca);
        miControladora.getMiPersistenciaLeñaSeca().crearLeñaSeca(miNuevaLeñaSeca);
    }

    public void eliminarLeñaSeca(int nro) throws NonexistentEntityException, Exception {
        misLeñasSecas = dameMisLeñasSecas();
        boolean encontro = false;
        LeñaSeca miLeñaSeca = null;

        for (int i = 0; i < misLeñasSecas.size() && !encontro; i++) {
            miLeñaSeca = misLeñasSecas.get(i);
            if (miLeñaSeca.getId() == nro) {
                encontro = true;
                misLeñasSecas.remove(i);
            }
        }

        miControladora.getMiPersistenciaLeñaSeca().eliminarLeñaSeca(nro);
    }

    public void modificarLeñaSeca(int nro, String tipo, double peso, Lote miLote, List<Insumo> misInsumos) throws NonexistentEntityException, Exception {
        misLeñasSecas = dameMisLeñasSecas();
        int pos = 0;
        boolean encuenetraLeñaSeca = false;
        LeñaSeca miLeñaSeca = null;

        for (int i = 0; i < misLeñasSecas.size() && !encuenetraLeñaSeca; i++) {
            miLeñaSeca = misLeñasSecas.get(i);
            if (miLeñaSeca.getId() == nro) {
                pos = i;
                encuenetraLeñaSeca = true;
            }
        }

        miLeñaSeca.setMiLote(miLote);
        miLeñaSeca.setPeso(peso);
        miLeñaSeca.setTipo(tipo);
        miLeñaSeca.setMisInsumos(misInsumos);

        misLeñasSecas.set(pos, miLeñaSeca);
        miControladora.getMiPersistenciaLeñaSeca().modificarLeñaSeca(miLeñaSeca);
    }

    public LeñaSeca dameUnLeñaSeca(int nro) {
        misLeñasSecas = dameMisLeñasSecas();
        boolean encontro = false;
        LeñaSeca miLeñaSeca = null;

        for (int i = 0; i < misLeñasSecas.size() && !encontro; i++) {
            miLeñaSeca = misLeñasSecas.get(i);
            if (miLeñaSeca.getId() == nro) {
                encontro = true;
            }
        }

        return miLeñaSeca;
    }

    public List<LeñaSeca> dameMisLeñasSecas() {
        misLeñasSecas = miControladora.getMiPersistenciaLeñaSeca().dameMisLeñaSeca();
        return misLeñasSecas;
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="Clase LeñaVerde">
    public void crearLeñaVerde(double porcentHumedad, double peso, Lote miLote, List<Insumo> misInsumos) throws PreexistingEntityException, Exception {

        misLeñasVerdes = dameMisLeñasVerdes();
        int nroLeñaVerde = misLeñasVerdes.size();
        boolean encontro = false;
        LeñaVerde miNuevaLeñaVerde = new LeñaVerde(porcentHumedad, nroLeñaVerde, peso, miLote, misInsumos);


        for (int i = 0; i < misLeñasVerdes.size() && !encontro; i++) {
            LeñaVerde miLeñaVerde = misLeñasVerdes.get(i);
            if (miLeñaVerde.getId() == nroLeñaVerde) {
                encontro = true;
                throw new PreexistingEntityException("LeñaVerde ya Existente.");
            }
        }

        misLeñasVerdes.add(miNuevaLeñaVerde);
        miControladora.getMiPersistenciaLeñaVerde().crearLeñaVerde(miNuevaLeñaVerde);
    }

    public void eliminarLeñaVerde(int nro) throws NonexistentEntityException, Exception {
        misLeñasVerdes = dameMisLeñasVerdes();
        boolean encontro = false;
        LeñaVerde miLeñaVerde = null;

        for (int i = 0; i < misLeñasVerdes.size() && !encontro; i++) {
            miLeñaVerde = misLeñasVerdes.get(i);
            if (miLeñaVerde.getId() == nro) {
                encontro = true;
                misLeñasVerdes.remove(i);
            }
        }

        miControladora.getMiPersistenciaLeñaVerde().eliminarLeñaVerde(nro);
    }

    public void modificarLeñaVerde(int nro, double porcentHumedad, double peso, Lote miLote, List<Insumo> misInsumos) throws NonexistentEntityException, Exception {
        misLeñasVerdes = dameMisLeñasVerdes();
        int pos = 0;
        boolean encuenetraLeñaVerde = false;
        LeñaVerde miLeñaVerde = null;

        for (int i = 0; i < misLeñasVerdes.size() && !encuenetraLeñaVerde; i++) {
            miLeñaVerde = misLeñasVerdes.get(i);
            if (miLeñaVerde.getId() == nro) {
                pos = i;
                encuenetraLeñaVerde = true;
            }
        }

        miLeñaVerde.setMiLote(miLote);
        miLeñaVerde.setPeso(peso);
        miLeñaVerde.setPorcentHumedad(porcentHumedad);
        miLeñaVerde.setMisInsumos(misInsumos);

        misLeñasVerdes.set(pos, miLeñaVerde);
        miControladora.getMiPersistenciaLeñaVerde().modificarLeñaVerde(miLeñaVerde);
    }

    public LeñaVerde dameUnLeñaVerde(int nro) {
        misLeñasVerdes = dameMisLeñasVerdes();
        boolean encontro = false;
        LeñaVerde miLeñaVerde = null;

        for (int i = 0; i < misLeñasVerdes.size() && !encontro; i++) {
            miLeñaVerde = misLeñasVerdes.get(i);
            if (miLeñaVerde.getId() == nro) {
                encontro = true;
            }
        }

        return miLeñaVerde;
    }

    public List<LeñaVerde> dameMisLeñasVerdes() {
        misLeñasVerdes = miControladora.getMiPersistenciaLeñaVerde().dameMisLeñaVerde();
        return misLeñasVerdes;
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="Clase YerbaVerde">
    public void crearYerbaVerde(double procentHumedad, double procentPalo, int id, double peso, Lote miLote, List<Insumo> misInsumos) throws PreexistingEntityException, Exception {

        misYerbasVerdes = dameMisYerbasVerdes();
        int nroYerbaVerde = misYerbasVerdes.size();
        boolean encontro = false;
        YerbaVerde miNuevaYerbaVerde = new YerbaVerde(procentHumedad, procentPalo, nroYerbaVerde, peso, miLote, misInsumos);


        for (int i = 0; i < misYerbasVerdes.size() && !encontro; i++) {
            YerbaVerde miYerbaVerde = misYerbasVerdes.get(i);
            if (miYerbaVerde.getId() == nroYerbaVerde) {
                encontro = true;
                throw new PreexistingEntityException("YerbaVerde ya Existente.");
            }
        }

        misYerbasVerdes.add(miNuevaYerbaVerde);
        miControladora.getMiPersistenciaYerbaVerde().crearYerbaVerde(miNuevaYerbaVerde);
    }

    public void eliminarYerbaVerde(int nro) throws NonexistentEntityException, Exception {
        misYerbasVerdes = dameMisYerbasVerdes();
        boolean encontro = false;
        YerbaVerde miYerbaVerde = null;

        for (int i = 0; i < misYerbasVerdes.size() && !encontro; i++) {
            miYerbaVerde = misYerbasVerdes.get(i);
            if (miYerbaVerde.getId() == nro) {
                encontro = true;
                misYerbasVerdes.remove(i);
            }
        }

        miControladora.getMiPersistenciaYerbaVerde().eliminarYerbaVerde(nro);
    }

    public void modificarYerbaVerde(double procentHumedad, double procentPalo, int id, double peso, Lote miLote, List<Insumo> misInsumos) throws NonexistentEntityException, Exception {
        misYerbasVerdes = dameMisYerbasVerdes();
        int pos = 0;
        boolean encuenetraYerbaVerde = false;
        YerbaVerde miYerbaVerde = null;

        for (int i = 0; i < misYerbasVerdes.size() && !encuenetraYerbaVerde; i++) {
            miYerbaVerde = misYerbasVerdes.get(i);
            if (miYerbaVerde.getId() == id) {
                pos = i;
                encuenetraYerbaVerde = true;
            }
        }

        miYerbaVerde.setMiLote(miLote);
        miYerbaVerde.setPeso(peso);
        miYerbaVerde.setProcentHumedad(procentHumedad);
        miYerbaVerde.setProcentPalo(procentPalo);
        miYerbaVerde.setMisInsumos(misInsumos);

        misYerbasVerdes.set(pos, miYerbaVerde);
        miControladora.getMiPersistenciaYerbaVerde().modificarYerbaVerde(miYerbaVerde);
    }

    public YerbaVerde dameUnYerbaVerde(int nro) {
        misYerbasVerdes = dameMisYerbasVerdes();
        boolean encontro = false;
        YerbaVerde miYerbaVerde = null;

        for (int i = 0; i < misYerbasVerdes.size() && !encontro; i++) {
            miYerbaVerde = misYerbasVerdes.get(i);
            if (miYerbaVerde.getId() == nro) {
                encontro = true;
            }
        }

        return miYerbaVerde;
    }

    public List<YerbaVerde> dameMisYerbasVerdes() {
        misYerbasVerdes = miControladora.getMiPersistenciaYerbaVerde().dameMisYerbaVerde();
        return misYerbasVerdes;
    }
    // </editor-fold>

    // <editor-fold defaultstate="collapsed" desc="Clase YerbaCanchada">
    public void crearYerbaCanchada(double porcentPalo, double porcentPolvo, double peso, Lote miLote, List<Insumo> misInsumos) throws PreexistingEntityException, Exception {

        misYerbasCanchadas = dameMisYerbasCanchadas();
        int nroYerbaCanchada = misYerbasCanchadas.size();
        boolean encontro = false;
        YerbaCanchada miNuevaYerbaCanchada = new YerbaCanchada(porcentPalo, porcentPolvo, nroYerbaCanchada, peso, miLote, misInsumos);


        for (int i = 0; i < misYerbasCanchadas.size() && !encontro; i++) {
            YerbaCanchada miYerbaCanchada = misYerbasCanchadas.get(i);
            if (miYerbaCanchada.getId() == nroYerbaCanchada) {
                encontro = true;
                throw new PreexistingEntityException("YerbaCanchada ya Existente.");
            }
        }

        misYerbasCanchadas.add(miNuevaYerbaCanchada);
        miControladora.getMiPersistenciaYerbaCanchada().crearYerbaCanchada(miNuevaYerbaCanchada);
    }

    public void eliminarYerbaCanchada(int nro) throws NonexistentEntityException, Exception {
        misYerbasCanchadas = dameMisYerbasCanchadas();
        boolean encontro = false;
        YerbaCanchada miYerbaCanchada = null;

        for (int i = 0; i < misYerbasCanchadas.size() && !encontro; i++) {
            miYerbaCanchada = misYerbasCanchadas.get(i);
            if (miYerbaCanchada.getId() == nro) {
                encontro = true;
                misYerbasCanchadas.remove(i);
            }
        }

        miControladora.getMiPersistenciaYerbaCanchada().eliminarYerbaCanchada(nro);
    }

    public void modificarYerbaCanchada(double porcentPalo, double porcentPolvo, int id, double peso, Lote miLote, List<Insumo> misInsumos) throws NonexistentEntityException, Exception {
        misYerbasCanchadas = dameMisYerbasCanchadas();
        int pos = 0;
        boolean encuenetraYerbaCanchada = false;
        YerbaCanchada miYerbaCanchada = null;

        for (int i = 0; i < misYerbasCanchadas.size() && !encuenetraYerbaCanchada; i++) {
            miYerbaCanchada = misYerbasCanchadas.get(i);
            if (miYerbaCanchada.getId() == id) {
                pos = i;
                encuenetraYerbaCanchada = true;
            }
        }

        miYerbaCanchada.setMiLote(miLote);
        miYerbaCanchada.setPeso(peso);
        miYerbaCanchada.setPorcentPalo(porcentPalo);
        miYerbaCanchada.setPorcentPolvo(porcentPolvo);
        miYerbaCanchada.setMisInsumos(misInsumos);

        misYerbasCanchadas.set(pos, miYerbaCanchada);
        miControladora.getMiPersistenciaYerbaCanchada().modificarYerbaCanchada(miYerbaCanchada);
    }

    public YerbaCanchada dameUnYerbaCanchada(int nro) {
        misYerbasCanchadas = dameMisYerbasCanchadas();
        boolean encontro = false;
        YerbaCanchada miYerbaCanchada = null;

        for (int i = 0; i < misYerbasCanchadas.size() && !encontro; i++) {
            miYerbaCanchada = misYerbasCanchadas.get(i);
            if (miYerbaCanchada.getId() == nro) {
                encontro = true;
            }
        }

        return miYerbaCanchada;
    }

    public List<YerbaCanchada> dameMisYerbasCanchadas() {
        misYerbasCanchadas = miControladora.getMiPersistenciaYerbaCanchada().dameMisYerbaCanchada();
        return misYerbasCanchadas;
    }
    // </editor-fold>
}
